.TH std::experimental::atomic_shared_ptr::operator= 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::atomic_shared_ptr::operator= \- std::experimental::atomic_shared_ptr::operator=

.SH Synopsis
   void operator=( shared_ptr<T> desired ) noexcept;    \fB(1)\fP
   void operator=( const atomic_shared_ptr& ) = delete; \fB(2)\fP

   1) Atomically assigns a value desired to the atomic variable. Equivalent to
   store(desired).
   2) Atomic variables are not CopyAssignable.

.SH Parameters

   desired - value to assign

.SH Notes

   Unlike most assignment operators, the assignment operators for atomic_shared_ptr
   returns void.

   Remarks

   All changes to the atomic_shared_ptr object itself, and all associated use_count
   increments, are guaranteed to be performed atomically. Associated use_count
   decrements take place after the atomic operation, but are not required to be part of
   it. Any associated destruction or deallocation operations take place after the
   atomic operation and are not part of it.

.SH See also

                                                                 constructs an
                                                                 atomic_shared_ptr
   constructor                                                   object
                                                                 \fI\fI(public member\fP\fP
                                                                 function)
                                                                 atomically replaces
                                                                 the value of the
   store                                                         atomic object with a
                                                                 non-atomic argument
                                                                 \fI\fI(public member\fP\fP
                                                                 function)
   std::atomic_is_lock_free(std::shared_ptr)
   std::atomic_load(std::shared_ptr)
   std::atomic_load_explicit(std::shared_ptr)
   std::atomic_store(std::shared_ptr)
   std::atomic_store_explicit(std::shared_ptr)                   specializes atomic
   std::atomic_exchange(std::shared_ptr)                         operations for
   std::atomic_exchange_explicit(std::shared_ptr)                std::shared_ptr
   std::atomic_compare_exchange_weak(std::shared_ptr)            \fI(function template)\fP
   std::atomic_compare_exchange_strong(std::shared_ptr)
   std::atomic_compare_exchange_weak_explicit(std::shared_ptr)
   std::atomic_compare_exchange_strong_explicit(std::shared_ptr)
   (deprecated in C++20)
   (removed in C++26)
